Setting Up Visual Studio Code and PyCharm for Python Development

Course: Python Training

Topic: Setting Up Visual Studio Code and PyCharm

Course Link: Python Training Course – JustAcademy

Demo Link: Register for a Python Course Demo

Academy Website: Visit JustAcademy

1. Introduction

A Python development environment is a collection of software tools used to write, execute, test, debug, and maintain Python programs. Choosing and configuring a suitable development environment helps developers work efficiently, identify errors quickly, organize projects, and manage dependencies.

Two popular development tools for Python are Visual Studio Code (VS Code) and PyCharm. VS Code is a lightweight, extensible code editor that supports Python through extensions. PyCharm is an integrated development environment (IDE) designed specifically for Python and related development workflows.

Both tools can be used to develop beginner-level scripts, automation programs, web applications, data-processing solutions, and larger software projects. The right choice depends on project requirements, personal preferences, available system resources, and the features needed.

2. Learning Objectives

• Understand the purpose of a Python code editor and IDE.
• Identify the main differences between Visual Studio Code and PyCharm.
• Install Python and verify that it works correctly.
• Download and configure Visual Studio Code for Python development.
• Install Python extensions and select the correct interpreter in VS Code.
• Install and configure PyCharm for Python projects.
• Create, run, and debug Python programs in both environments.
• Understand virtual environments, project folders, and package installation.
• Troubleshoot common setup and execution errors.

3. Understanding a Python Development Environment

A development environment provides the tools and configuration needed to create and run programs. For Python, it commonly includes the Python interpreter, a code editor or IDE, a terminal, debugging tools, and a way to manage third-party packages.

3.1 Main Components

3.2 What Is a Code Editor?

A code editor is an application for creating and editing source code. Modern editors may provide syntax highlighting, code completion, integrated terminals, extensions, and debugging support.

Visual Studio Code is a widely used example. Its Python capabilities are added and enhanced through extensions.

3.3 What Is an IDE?

An Integrated Development Environment combines several development tools into one application. An IDE may provide code editing, project navigation, debugging, testing support, interpreter configuration, and package-management features.

PyCharm is a Python-focused IDE that offers many Python development features in an integrated interface.

4. System Requirements and Preparation

Before installing either tool, ensure that your computer has sufficient storage, memory, and operating-system support for the chosen versions. Exact requirements can change between releases, so check the official download pages before installation.

4.1 Basic Preparation Checklist

• Use a supported version of Windows, macOS, or Linux.
• Check that you have permission to install applications.
• Ensure that an internet connection is available for downloads and extensions.
• Install a supported Python 3 version.
• Choose a dedicated folder for Python projects.
• Keep project files and virtual environments organized.

4.2 Download Links

• Download Python from the official Python website
• Download Visual Studio Code
• Download PyCharm

5. Installing Python

Python must be installed and accessible to the development tool before Python scripts can be executed. Some tools can help locate an existing interpreter, but they do not necessarily install Python itself.

5.1 Download Python

1. Open the official Python downloads page.
2. Select a stable release compatible with your operating system and development tools.
3. Download the appropriate installer.
4. Run the installer and follow the on-screen instructions.
5. On Windows, enable the option to add Python to PATH if the installer provides it and you want to run Python from the terminal.
6. Complete the installation.

5.2 Verify the Installation

Open a terminal and run the appropriate command:

python --version

On some systems, use:

python3 --version

To verify that pip is available, run:

python -m pip --version

The terminal should display the installed Python or pip version. If the command is not recognized, the interpreter may not be installed correctly or may not be available on PATH. On Windows, the Python launcher may also be available through:

py --version

5.3 Why the Python Interpreter Matters

The interpreter converts Python instructions into actions the computer can execute. The selected interpreter determines the Python version and the installed packages available to the project.

For example, a package installed in one virtual environment may not be available when a different interpreter is selected. Correct interpreter selection is therefore essential when working with multiple projects.

6. Setting Up Visual Studio Code

6.1 What Is Visual Studio Code?

Visual Studio Code, commonly called VS Code, is a code editor that supports multiple programming languages. Python support is provided through extensions that add features such as code completion, linting, debugging, testing, and interpreter selection.

6.2 Install Visual Studio Code

1. Visit the official Visual Studio Code website.
2. Download the installer for your operating system.
3. Run the installer.
4. Accept the applicable terms and choose the required installation options.
5. Complete installation and launch VS Code.

6.3 Open a Python Project Folder

It is good practice to keep related source files in a dedicated project folder. For example, create a folder named python-practice.

1. Launch VS Code.
2. Select File > Open Folder.
3. Choose the python-practice folder.
4. Confirm that the folder appears in the Explorer panel.
5. Create a new file named hello.py.

Opening the project folder instead of an individual file makes it easier to manage multiple files and project resources together.

6.4 Install the Python Extension

1. Open the Extensions view using the Extensions icon in the Activity Bar.
2. Search for Python.
3. Choose the Python extension published by Microsoft.
4. Select Install and wait for installation to finish.
5. Follow any prompts to reload or configure the editor.

The Python extension provides Python-specific editing and development features. Depending on your workflow, you may also install related extensions for Python debugging, testing, linting, formatting, or Jupyter notebooks. Install only the tools you need.

6.5 Select the Python Interpreter

VS Code may detect multiple Python interpreters on your computer. Selecting the intended interpreter ensures that the editor, terminal workflow, and project use the correct Python installation or virtual environment.

1. Open the project folder in VS Code.
2. Open the Command Palette using Ctrl+Shift+P on Windows or Linux, or Cmd+Shift+P on macOS.
3. Search for Python: Select Interpreter.
4. Select the Python installation or virtual environment intended for the project.
5. Check the interpreter information displayed by the editor when available.

If the desired interpreter is not listed, confirm that Python is installed and try refreshing the available interpreter list or selecting the interpreter path manually.

6.6 Create and Run a Python File in VS Code

Enter the following code in hello.py:

print("Hello, Python!")
print("Welcome to Visual Studio Code.")

Save the file and run it using the editor's available Python run command or the integrated terminal.

To run it manually from the terminal, navigate to the folder containing the file and enter:

python hello.py

If your system uses the python3 command, run:

python3 hello.py

Expected output:

Hello, Python!
Welcome to Visual Studio Code.

6.7 Use the Integrated Terminal

The integrated terminal allows you to execute commands without leaving VS Code. Open it through Terminal > New Terminal.

For example, you can check Python's version, run a script, create a virtual environment, and install packages from the terminal:

python --version
python hello.py
python -m venv .venv

The exact commands may vary depending on your operating system and Python installation.

6.8 Configure Code Formatting and Linting

Code formatting tools help maintain consistent spacing and layout. Linters identify potential errors, suspicious code, and style problems.

For example, you can install a formatter such as Black inside your project's selected environment:

python -m pip install black

You can then format a Python file from the terminal:

python -m black hello.py

A linter such as Ruff can be installed in the same way:

python -m pip install ruff
python -m ruff check .

Configure these tools through the editor or project settings if you want automatic formatting or linting. The available options depend on the extensions installed and their current versions.

7. Setting Up PyCharm

7.1 What Is PyCharm?

PyCharm is an IDE developed by JetBrains with features designed for Python development. It supports project-based workflows, code navigation, debugging, testing, interpreter configuration, and virtual environments.

PyCharm has different editions and licensing arrangements. Available features can differ by edition and release, so check the official PyCharm website for current details.

7.2 Download and Install PyCharm

1. Visit the official PyCharm download page.
2. Select the version suitable for your operating system.
3. Download the installer.
4. Run the installer and follow the setup instructions.
5. Launch PyCharm after installation.
6. Review any initial configuration or welcome-screen options.

7.3 Create a New Python Project

1. Open PyCharm.
2. Choose New Project from the welcome screen.
3. Specify a project name and location, such as python-practice.
4. Choose an appropriate interpreter configuration.
5. Create a new virtual environment if the project wizard offers that option.
6. Select a compatible base Python interpreter.
7. Complete the project creation process.

PyCharm may create a virtual environment automatically depending on your project settings. Confirm the selected interpreter before installing dependencies or running your code.

7.4 Configure the Python Interpreter

The Python interpreter determines which Python executable runs your program and which packages are available. PyCharm supports configuring project interpreters, including virtual environments.

1. Open the project in PyCharm.
2. Open the project settings or interpreter configuration section. The exact menu location can vary by release and operating system.
3. Locate the Python interpreter settings.
4. Select an existing interpreter or add a new one.
5. If creating a virtual environment, select the base Python installation and the environment location.
6. Apply the changes and wait for the environment to initialize.

7.5 Create a Python File in PyCharm

1. Locate the project folder in the Project tool window.
2. Right-click the project folder.
3. Select New and then choose Python File.
4. Name the file hello.
5. Enter the following code:

def greet(name):
    return f"Hello, {name}!"

message = greet("Python")
print(message)

Expected output:

Hello, Python!

7.6 Run a Python Program in PyCharm

1. Save the Python file.
2. Right-click inside the editor or on the file in the Project tool window.
3. Choose the available Run command.
4. Review the output in the Run tool window.
5. Check any error messages if the program does not execute successfully.

PyCharm can save run configurations for repeated executions. These configurations may specify the script, working directory, interpreter, environment variables, and command-line arguments.

7.7 Debug a Program in PyCharm

The debugger lets you pause a program and inspect its state. You can set breakpoints, execute code one step at a time, and examine variables to understand why a program behaves unexpectedly.

def calculate_total(price, quantity):
    total = price * quantity
    return total

amount = calculate_total(250, 3)
print(amount)

Set a breakpoint on the line that calculates total, then run the program using the Debug action. When execution pauses, inspect price, quantity, and total.

Expected final output:

750

8. Visual Studio Code vs. PyCharm

8.1 Which Tool Should Beginners Choose?

Both tools are suitable for learning Python. VS Code is a good option for learners who prefer a customizable editor that can support several languages. PyCharm is useful for learners who want project management, interpreter configuration, and Python development features integrated into one application.

There is no universal winner. Try both tools if possible and choose the environment that makes writing, running, and understanding code easiest for you.

9. Creating a Virtual Environment

A virtual environment is an isolated Python environment for a particular project. It helps prevent dependencies for one project from interfering with another project.

9.1 Why Use a Virtual Environment?

• Keep project dependencies separate.
• Use different package versions in different projects.
• Make it easier to reproduce a project's setup.
• Avoid unnecessarily installing project packages globally.
• Reduce conflicts between development environments.

9.2 Create a Virtual Environment

From the root directory of your project, run:

python -m venv .venv

On systems where Python is invoked as python3, use:

python3 -m venv .venv

9.3 Activate the Virtual Environment

On Windows using Command Prompt:

.venv\Scripts\activate.bat

On Windows using PowerShell:

.\.venv\Scripts\Activate.ps1

On macOS or Linux:

source .venv/bin/activate

When activation succeeds, the terminal often displays the environment name. If PowerShell blocks the activation script, review the applicable PowerShell execution policy and your organization's security guidance. You can also invoke the environment's Python executable directly without activating it.

9.4 Install a Package in the Environment

With the intended environment active, install a package using:

python -m pip install requests

Check installed packages with:

python -m pip list

For a simple project, you can record its dependencies in a requirements file:

python -m pip freeze > requirements.txt

On another compatible environment, the recorded dependencies can be installed with:

python -m pip install -r requirements.txt

Review the generated file before sharing it. The output may include every installed package in the environment, including packages that are not direct project dependencies.

9.5 Use a Virtual Environment in VS Code

1. Create the environment in the project directory.
2. Open the Command Palette.
3. Select Python: Select Interpreter.
4. Choose the interpreter located inside .venv.
5. Open a new terminal if needed.
6. Run your Python file and verify that the selected environment is being used.

9.6 Use a Virtual Environment in PyCharm

1. Open the project settings or interpreter configuration.
2. Add or select a virtual environment.
3. Choose the base Python installation and environment location.
4. Confirm that the project interpreter points to the intended environment.
5. Install required packages through the IDE's package-management interface or the environment's terminal.

10. Organizing a Python Project

A clear project structure makes source code easier to maintain, test, and share. Even small practice projects benefit from descriptive file and folder names.

10.1 Example Project Structure

python-practice/
├── .venv/
├── main.py
├── requirements.txt
├── README.md
├── .gitignore
└── tests/
    └── test_main.py

File and folder purposes:

• .venv/: Contains the project's virtual environment. It is usually recreated rather than committed to version control.
• main.py: Contains the main program or entry point for a simple project.
• requirements.txt: Lists Python packages needed by the project.
• README.md: Explains the project's purpose, setup, and usage.
• .gitignore: Lists files and folders Git should ignore.
• tests/: Contains automated tests.

10.2 Example .gitignore File

.venv/
__pycache__/
*.py[cod]
.env
.idea/
.vscode/

The final two entries are optional. Excluding .idea/ or .vscode/ can be appropriate for personal settings, but teams sometimes commit selected project configuration files. Do not ignore configuration files that the team intentionally shares.

11. Writing and Running a Practical Python Program

After installing and configuring the editor, practice with a small program that accepts user input, performs a calculation, and displays a result.

11.1 Example: Simple Calculator

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        return "Error: Cannot divide by zero."
    return a / b

num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

print("Addition:", add(num1, num2))
print("Subtraction:", subtract(num1, num2))
print("Multiplication:", multiply(num1, num2))
print("Division:", divide(num1, num2))

11.2 Steps to Execute the Program

1. Create a file named calculator.py.
2. Copy the program into the file.
3. Save the file.
4. Ensure that the correct Python interpreter is selected.
5. Run the program using the editor's run command or terminal.
6. Enter two numeric values when prompted.
7. Check the results and test division by zero.

11.3 Example Output

Enter the first number: 12
Enter the second number: 4
Addition: 16.0
Subtraction: 8.0
Multiplication: 48.0
Division: 3.0

This program demonstrates how an editor or IDE supports the full development process: writing source code, executing it, observing output, and correcting errors.

12. Debugging in VS Code and PyCharm

Debugging is the process of locating and fixing defects in a program. Instead of relying only on printed output, a debugger lets you pause execution and examine variables and program flow.

12.1 Common Debugging Features

12.2 Example of a Logical Error

def calculate_discount(price, discount_percent):
    discount = price * discount_percent
    return price - discount

print(calculate_discount(1000, 10))

The program runs, but the calculation is wrong because the discount percentage is used as a whole number rather than a fraction. Change the calculation to:

def calculate_discount(price, discount_percent):
    discount = price * discount_percent / 100
    return price - discount

print(calculate_discount(1000, 10))

Expected output:

900.0

Use a breakpoint to inspect the input values and intermediate calculation. This helps distinguish logical errors from syntax errors and environment configuration problems.

13. Common Setup Problems and Solutions

13.1 How to Diagnose a Missing Package

Suppose a program contains:

import requests

response = requests.get("https://example.com")
print(response.status_code)

If Python reports ModuleNotFoundError: No module named 'requests', the package may not be installed in the active environment. Run the following using the same interpreter that executes the script:

python -m pip install requests

Then verify that the project is using the expected interpreter. The issue is often caused by installing a package in one Python environment while running the program in another.

14. Best Practices for Python Development Environments

• Use a supported Python version: Prefer a version compatible with your project and required libraries.
• Use virtual environments: Keep project dependencies isolated.
• Select the interpreter carefully: Verify the environment before running or debugging code.
• Use meaningful file names: Choose names such as calculator.py or data_cleaning.py.
• Save files frequently: Confirm that the latest changes are saved before execution.
• Keep dependencies documented: Maintain a requirements file or another appropriate dependency specification.
• Use version control: Track source-code changes with Git.
• Follow consistent formatting: Use readable indentation, descriptive names, and a consistent code style.
• Test small changes: Run code regularly rather than waiting until the end of a large task.
• Read error messages: Start with the final line of a traceback and then inspect the relevant code location.
• Protect secrets: Do not commit passwords, API keys, or private configuration values to a public repository.
• Keep tools updated sensibly: Review updates and compatibility before changing a working development environment.

15. Practical Exercises

Exercise 1: Install and Verify Python

• Download and install Python.
• Run the Python version command in the terminal.
• Verify that pip is available.
• Record the Python version and operating system used.

Exercise 2: Configure Visual Studio Code

• Install VS Code.
• Install the Python extension published by Microsoft.
• Create a project folder and open it.
• Create a file named student.py.
• Print your name, course, and a short learning goal.
• Run the program and verify its output.

Exercise 3: Configure PyCharm

• Install PyCharm.
• Create a project with a valid Python interpreter.
• Create a file named marks.py.
• Calculate the average of three marks.
• Run the program and inspect its output.

Exercise 4: Work with Virtual Environments

• Create a virtual environment named .venv.
• Activate it using the command for your operating system.
• Install a small third-party package.
• Confirm the package is available in the environment.
• Select the environment as the project interpreter in your editor or IDE.

Exercise 5: Debug a Program

• Write a function that calculates the total price after a discount.
• Set a breakpoint inside the function.
• Run the program in debug mode.
• Inspect the input values and intermediate variables.
• Correct any logic errors and test the program with several inputs.

16. Mini Project: Student Result Calculator

Objective: Create and execute a Python program that accepts student marks, calculates the average, and displays a result category.

16.1 Project Code

def calculate_average(marks):
    if not marks:
        raise ValueError("At least one mark is required.")

    if any(mark < 0 or mark > 100 for mark in marks):
        raise ValueError("Marks must be between 0 and 100.")

    return sum(marks) / len(marks)


def get_result(average):
    if average >= 80:
        return "Distinction"
    elif average >= 60:
        return "First Class"
    elif average >= 40:
        return "Pass"
    return "Needs Improvement"


marks = [85, 78, 92, 88, 75]

average = calculate_average(marks)
result = get_result(average)

print("Marks:", marks)
print("Average:", round(average, 2))
print("Result:", result)

16.2 Expected Output

Marks: [85, 78, 92, 88, 75]
Average: 83.6
Result: Distinction

16.3 Project Tasks

1. Create a project in VS Code or PyCharm.
2. Save the code in student_result.py.
3. Run the program and verify the output.
4. Change the marks and test the result categories.
5. Try invalid marks and observe how the program handles them.
6. Set a breakpoint inside calculate_average() and inspect the values.
7. Document how to run the project in a README file.

17. Interview Questions and Answers

Q1. What is Visual Studio Code?

Answer: Visual Studio Code is a customizable code editor that supports Python and other programming languages through extensions. It provides editing, terminal, debugging, and other development features.

Q2. What is PyCharm?

Answer: PyCharm is an IDE designed primarily for Python development. It includes project navigation, interpreter configuration, debugging, and other integrated development features.

Q3. What is the difference between a code editor and an IDE?

Answer: A code editor focuses on writing and editing code and may gain extra capabilities through extensions. An IDE combines editing with a broader set of integrated development tools. Modern code editors and IDEs can overlap in functionality.

Q4. Is Python included automatically when installing VS Code?

Answer: No. Installing VS Code does not necessarily install the Python interpreter. Python must be installed separately or made available through an appropriate environment.

Q5. Why is the Python extension needed in VS Code?

Answer: The Python extension adds Python-specific features such as interpreter selection, code assistance, debugging, and testing integration.

Q6. What is a Python interpreter?

Answer: A Python interpreter executes Python code. The chosen interpreter determines the Python version and the packages available to the running program.

Q7. What is a virtual environment?

Answer: A virtual environment is an isolated Python environment that helps manage project-specific packages independently from other projects and the global Python installation.

Q8. How do you create a virtual environment?

Answer: Run python -m venv .venv from the project directory, then activate the environment using the command appropriate for your operating system and shell.

Q9. How do you run a Python file from the terminal?

Answer: Navigate to the file's directory and run python filename.py. Depending on the system, python3 filename.py or another configured Python launcher may be required.

Q10. What causes ModuleNotFoundError?

Answer: It usually means Python cannot find the requested module in the active environment. Check the selected interpreter and install the dependency into the environment used to run the program.

Q11. What is debugging?

Answer: Debugging is the process of finding and correcting errors. A debugger allows developers to pause execution, inspect variables, follow program flow, and test assumptions.

Q12. What is a breakpoint?

Answer: A breakpoint marks a line where the debugger should pause execution so the developer can inspect the program's current state.

Q13. Can the same Python project be opened in VS Code and PyCharm?

Answer: Yes. Both tools can work with the same project files. Ensure that each tool uses the correct interpreter and project configuration.

Q14. Why might a program run in the terminal but fail in the editor?

Answer: The terminal and editor may be using different Python interpreters, virtual environments, working directories, or environment variables.

Q15. Which is better for Python beginners: VS Code or PyCharm?

Answer: Both are suitable. VS Code offers a flexible editor with extension-based Python support, while PyCharm offers an integrated Python development workflow. The best choice depends on learning preferences and project needs.

18. Quick Revision Checklist

• Understand the purpose of a Python development environment.
• Install Python and verify the interpreter from a terminal.
• Install VS Code or PyCharm.
• Configure the correct Python interpreter.
• Create a project folder and a Python source file.
• Run a Python script and inspect its output.
• Create and use a virtual environment.
• Install packages in the correct environment.
• Use breakpoints and debugging tools to investigate errors.
• Organize project files and document dependencies.
• Follow good practices for formatting, version control, and secret management.

19. Conclusion

Setting up Visual Studio Code and PyCharm is an important step in learning Python development. Both tools help programmers write, run, test, and debug Python applications, but they provide different approaches to the development workflow.

VS Code offers a flexible editor that gains Python capabilities through extensions. PyCharm provides a Python-focused IDE with integrated project and development tools. In either environment, correctly installing Python, selecting the intended interpreter, using virtual environments, and organizing project files are essential skills.

Practise creating small programs, running them from the editor and terminal, debugging errors, and managing dependencies. These skills establish a strong foundation for more advanced Python topics, including automation, web development, data analysis, and application development.

To explore structured learning opportunities, visit the Python Training Course at JustAcademy, register for a course demo, or explore the JustAcademy website.